import { isArray } from "@/helper/is";
import { FieldNamesProps } from "@/components/ProTable/interface";
import {MenuOptions} from "@/interface";
import { Menu } from "@/interface/api";

/**
 * @description 获取localStorage
 * @param {String} key Storage名称
 * @returns {String}
 */
export function localGet(key: string) {
    const value = window.localStorage.getItem(key);
    try {
        return JSON.parse(window.localStorage.getItem(key) as string);
    } catch (error) {
        return value;
    }
}

/**
 * @description 存储localStorage
 * @param {String} key Storage名称
 * @param {*} value Storage值
 * @returns {void}
 */
export function localSet(key: string, value: any) {
    window.localStorage.setItem(key, JSON.stringify(value));
}

/**
 * @description 清除localStorage
 * @param {String} key Storage名称
 * @returns {void}
 */
export function localRemove(key: string) {
    window.localStorage.removeItem(key);
}

/**
 * @description 清除所有localStorage
 * @returns {void}
 */
export function localClear() {
    window.localStorage.clear();
}

/**
 * @description 判断数据类型
 * @param {*} val 需要判断类型的数据
 * @returns {String}
 */
export function isType(val: any) {
    if (val === null) return "null";
    if (typeof val !== "object") return typeof val;
    else return Object.prototype.toString.call(val).slice(8, -1).toLocaleLowerCase();
}

// 获取图片链接
export const srcUrl = (filePath: string) => {
    return new URL(`/src/assets/${filePath}`, import.meta.url).href;
}

/**
 * @description 生成唯一 uuid
 * @returns {String}
 */
export function generateUUID() {
    let uuid = "";
    for (let i = 0; i < 32; i++) {
        let random = (Math.random() * 16) | 0;
        if (i === 8 || i === 12 || i === 16 || i === 20) uuid += "-";
        uuid += (i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random).toString(16);
    }
    return uuid;
}

/**
 * 判断两个对象是否相同
 * @param {Object} a 要比较的对象一
 * @param {Object} b 要比较的对象二
 * @returns {Boolean} 相同返回 true，反之 false
 */
export function isObjectValueEqual(a: { [key: string]: any }, b: { [key: string]: any }) {
    if (!a || !b) return false;
    let aProps = Object.getOwnPropertyNames(a);
    let bProps = Object.getOwnPropertyNames(b);
    if (aProps.length != bProps.length) return false;
    for (let i = 0; i < aProps.length; i++) {
        let propName = aProps[i];
        let propA = a[propName];
        let propB = b[propName];
        if (!b.hasOwnProperty(propName)) return false;
        if (propA instanceof Object) {
            if (!isObjectValueEqual(propA, propB)) return false;
        } else if (propA !== propB) {
            return false;
        }
    }
    return true;
}

/**
 * @description 生成随机数
 * @param {Number} min 最小值
 * @param {Number} max 最大值
 * @returns {Number}
 */
export function randomNum(min: number, max: number): number {
    let num = Math.floor(Math.random() * (min - max) + max);
    return num;
}

/**
 * @description 获取当前时间对应的提示语
 * @returns {String}
 */
export function getTimeState() {
    let timeNow = new Date();
    let hours = timeNow.getHours();
    if (hours >= 6 && hours <= 10) return `早上好 ⛅`;
    if (hours >= 10 && hours <= 14) return `中午好 🌞`;
    if (hours >= 14 && hours <= 18) return `下午好 🌞`;
    if (hours >= 18 && hours <= 24) return `晚上好 🌛`;
    if (hours >= 0 && hours <= 6) return `凌晨好 🌛`;
}

/**
 * 日期字符串转换可视化时间差字符串
 * @param dateStr
 */
export function dateDiffStr(dateStr: string) {
    const timeStamp = new Date(dateStr).getTime();
    const minute = 1000 * 60;
    const hour = minute * 60;
    const day = hour * 24;
    const month = day * 30;
    const now = new Date().getTime();
    const diffValue = now - timeStamp;
    if (diffValue < 0) {
        //若日期不符则弹出窗口告之
        //alert("结束日期不能小于开始日期！");
    }
    const monthC = diffValue / month;
    const weekC = diffValue / (7 * day);
    const dayC = diffValue / day;
    const hourC = diffValue / hour;
    const minC = diffValue / minute;
    let result;
    if (monthC >= 1) {
        result = parseInt(String(monthC)) + "个月前";
    } else if (weekC >= 1) {
        result = parseInt(String(weekC)) + "周前";
    } else if (dayC >= 1) {
        result = parseInt(String(dayC)) + "天前";
    } else if (hourC >= 1) {
        result = parseInt(String(hourC)) + "小时前";
    } else if (minC >= 1) {
        result = parseInt(String(minC)) + "分钟前";
    } else {
        result = "刚刚";
    }
    return result;
}

/**
 * @description 获取浏览器默认语言
 * @returns {String}
 */
export function getBrowserLang() {
    let browserLang = navigator.language ? navigator.language : "zh";
    let defaultBrowserLang = "";
    if (["cn", "zh", "zh-cn"].includes(browserLang.toLowerCase())) {
        defaultBrowserLang = "zh";
    } else {
        defaultBrowserLang = "en";
    }
    return defaultBrowserLang;
}

/**
 * @description 根据后台返回的菜单数据组织成前端需要的菜单列表
 * @param data Menu[]
 * @param menuList
 * @return MenuOptions[]
 */
export function renderMenuOptions(data: Menu[], menuList: MenuOptions[] = []) {
    if (!data || data.length == 0) {
        return menuList;
    }
    data.forEach(item => {
        let menu: MenuOptions = {
            name: item.name,
            path: item.router,
            type: item.type,
            component_path: item.link && item.iframe == 1 ? "/iframe/index" : item.component,
            meta: {
                icon_type: item.icon_type,
                icon_name: item.icon_name,
                title: item.title,
                link: item.link,
                id: item.id,
                pid: item.pid,
                iframe: item.iframe == 1,
                hidden: item.hidden == 1,
                full_screen: item.full_screen == 1,
                is_fixed: item.is_fixed == 1,
                keep_alive: item.keep_alive == 1,
            }
        };
        if (item.children && item.children.length > 0) {
            if ((item.type === 1 || item.type === 2) && item.children && item.children.length > 0) {
                menu.redirect = item.children[0].router;
            }
            menuList.push(menu);
            menu.children = renderMenuOptions(item.children, menuList);
        } else {
            menuList.push(menu);
        }
    });
}

/**
 * @description 使用递归过滤出需要渲染在左侧菜单的列表 (需剔除 isHide == true 的菜单)
 * @param {Array} menuList 菜单列表
 * @returns {Array}
 * */
export function getShowMenuList(menuList: Menu[]) {
    let newMenuList: Menu[] = JSON.parse(JSON.stringify(menuList));
    return newMenuList.filter(item => {
        item.children?.length && (item.children = getShowMenuList(item.children));
        return !item.hidden;
    });
}

/**
 * @description 使用递归扁平化菜单，方便添加动态路由
 * @param {Array} menuList 菜单列表
 * @returns {Array}
 */
export function getFlatMenuList(menuList: MenuOptions[]): MenuOptions[] {
    let newMenuList: MenuOptions[] = JSON.parse(JSON.stringify(menuList));
    return newMenuList.flatMap(item => [item, ...(item.children ? getFlatMenuList(item.children) : [])]);
}

/**
 * @description 使用递归找出所有面包屑存储到 pinia/vuex 中
 * @param {Array} menuList 菜单列表
 * @param {Object} result 处理后的结果
 * @returns {Object}
 */
export const getAllBreadcrumbList = (menuList: MenuOptions[], result: { [key: string]: any } = {}) => {
    for (const item of menuList) {
        result[item.path] = item;
    }
    return result;
};

/**
 * @description 使用递归处理路由菜单 path，生成一维数组 (第一版本地路由鉴权会用到，该函数暂未使用)
 * @param {Array} menuList 所有菜单列表
 * @param {Array} menuPathArr 菜单地址的一维数组 ['**','**']
 * @returns {Array}
 */
export function getMenuListPath(menuList: MenuOptions[], menuPathArr: string[] = []): string[] {
    for (const item of menuList) {
        if (typeof item === "object" && item.path) menuPathArr.push(item.path);
        if (item.children?.length) getMenuListPath(item.children, menuPathArr);
    }
    return menuPathArr;
}

/**
 * @description 递归查询当前 path 所对应的菜单对象 (该函数暂未使用)
 * @param {Array} menuList 菜单列表
 * @param {String} path 当前访问地址
 * @returns {Object | null}
 */
export function findMenuByPath(menuList: MenuOptions[], path: string): MenuOptions | null {
    for (const item of menuList) {
        if (item.path === path) return item;
        if (item.children) {
            const res = findMenuByPath(item.children, path);
            if (res) return res;
        }
    }
    return null;
}

export function recursiveFindActiveMenu(flatMenuList: MenuOptions[], pid: number) {
    for (const item of flatMenuList) {
        if (item.meta.id == pid) {
            if (item.meta.pid == 0) {
                return item;
            } else {
                return recursiveFindActiveMenu(flatMenuList, item.meta.pid);
            }
        }
    }
}

/**
 * @description 过滤需要缓存的菜单 name (该函数暂未使用)
 * @param {Array} flatMenuList 所有扁平化的菜单列表
 * @returns {Array}
 * */
export function getKeepAliveRouterNames(flatMenuList: MenuOptions[]) {
    let keepAliveNames = <string[]>([]);
    flatMenuList.forEach(item => {
        item.meta.keep_alive && item.name && keepAliveNames.push(item.name);
    });
    return keepAliveNames;
}

/**
 * @description 格式化表格单元格默认值 (el-table-column)
 * @param {Number} _row 行
 * @param {Number} _col 列
 * @param {*} callValue 当前单元格值
 * @returns {String}
 * */
export function formatTableColumn(_row: number, _col: number, callValue: any) {
    // 如果当前值为数组，使用 / 拼接（根据需求自定义）
    if (isArray(callValue)) return callValue.length ? callValue.join(" / ") : "--";
    return callValue ?? "--";
}

/**
 * @description 处理值无数据情况
 * @param {*} callValue 需要处理的值
 * @returns {String}
 * */
export function formatValue(callValue: any) {
    // 如果当前值为数组，使用 / 拼接（根据需求自定义）
    if (isArray(callValue)) return callValue.length ? callValue.join(" / ") : "--";
    return callValue ?? "--";
}

/**
 * @description 处理 prop 为多级嵌套的情况，返回的数据 (列如: prop: user.name)
 * @param {Object} row 当前行数据
 * @param {String} prop 当前 prop
 * @returns {*}
 * */
export function handleRowAccordingToProp(row: { [key: string]: any }, prop: string) {
    if (!prop.includes(".")) return row[prop] ?? "--";
    prop.split(".").forEach(item => (row = row[item] ?? "--"));
    return row;
}

/**
 * @description 处理 prop，当 prop 为多级嵌套时 ==> 返回最后一级 prop
 * @param {String} prop 当前 prop
 * @returns {String}
 * */
export function handleProp(prop: string) {
    const propArr = prop.split(".");
    if (propArr.length == 1) return prop;
    return propArr[propArr.length - 1];
}

/**
 * @description 根据枚举列表查询当需要的数据（如果指定了 label 和 value 的 key值，会自动识别格式化）
 * @param {String} callValue 当前单元格值
 * @param {Array} enumData 字典列表
 * @param {Array} fieldNames label && value && children 的 key 值
 * @param {String} type 过滤类型（目前只有 tag）
 * @returns {String}
 * */
export function filterEnum(callValue: any, enumData?: any, fieldNames?: FieldNamesProps, type?: "tag") {
    const value = fieldNames?.value ?? "value";
    const label = fieldNames?.label ?? "label";
    const children = fieldNames?.children ?? "children";
    let filterData: { [key: string]: any } = {};
    // 判断 enumData 是否为数组
    if (Array.isArray(enumData)) filterData = findItemNested(enumData, callValue, value, children);
    // 判断是否输出的结果为 tag 类型
    if (type == "tag") {
        return filterData?.tagType ? filterData.tagType : "";
    } else {
        return filterData ? filterData[label] : "--";
    }
}

/**
 * @description 递归查找 callValue 对应的 enum 值
 * */
export function findItemNested(enumData: any, callValue: any, value: string, children: string) {
    return enumData.reduce((accumulator: any, current: any) => {
        if (accumulator) return accumulator;
        if (current[value] === callValue) return current;
        if (current[children]) return findItemNested(current[children], callValue, value, children);
    }, null);
}

/**
 * @description 获取音频时长
 * @param audioUrl
 */
export function getAudioDuration(audioUrl: string): Promise<number> {
    return new Promise((resolve, reject) => {
        const audio = new Audio(audioUrl);

        // 当音频加载的元数据足够时，metadataLoaded 事件会被触发（注意：不是所有浏览器都支持这个事件）
        // 如果浏览器不支持metadataLoaded事件，我们可以使用canplaythrough事件作为替代
        audio.addEventListener('metadataLoaded', () => {
            // 使用 duration 属性获取音频时长（以秒为单位）
            resolve(audio.duration);
        });

        audio.addEventListener('canplaythrough', () => {
            // 这是一个更普遍支持的事件，当浏览器能够播放音频且预计不需要缓冲中断时触发
            resolve(audio.duration);
        });

        audio.addEventListener('error', (error) => {
            // 处理加载音频时发生的错误
            reject(error);
        });

        // 加载音频
        audio.load();
    });
}

/**
 * 获取视频第一帧
 * @param videoUrl
 */
export function captureFirstFrame(videoUrl: string) : Promise<string> {
    return new Promise((resolve, reject) => {
        if (!videoUrl) {
            return reject('No video url provided');
        }

        // 创建一个视频元素
        let videoElement: HTMLVideoElement | null = document.createElement('video');
        videoElement.crossOrigin = 'anonymous';
        videoElement.src = videoUrl;
        videoElement.style.display = 'none'; // 隐藏视频元素
        document.body.appendChild(videoElement); // 将视频元素添加到DOM中（为了播放）

        // 监听视频的loadeddata事件，确保视频元数据已加载
        videoElement.addEventListener('loadeddata', () => {
            // 跳转到视频的第一帧（通常是0秒）
            videoElement!.currentTime = 0;

            videoElement!.onseeked = () => {
                // 创建一个canvas元素
                const canvas = document.createElement('canvas');
                const context = canvas.getContext('2d');

                // 设置canvas的大小与视频的大小一致
                canvas.width = videoElement!.videoWidth * 0.5;
                canvas.height = videoElement!.videoHeight * 0.5;

                // 将视频的第一帧绘制到canvas上
                context!.drawImage(videoElement!, 0, 0, canvas.width, canvas.height);

                // 清理：从DOM中移除视频元素，并设置为null以便垃圾回收
                document.body.removeChild(videoElement!);
                videoElement = null;

                // 获取canvas的data:image/png格式的base64编码
                const preview = canvas.toDataURL('image/png');
                console.log(preview);
                resolve(preview.substring('data:image/png;base64,'.length));
            }
        });

        videoElement.addEventListener('error', (error) => {
            // 处理加载音频时发生的错误
            reject(error);
        });

        // 触发视频的加载，以便loadeddata事件可以被触发
        videoElement.load();
    });
}
